home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / gdb-4.5 / dist / gdb / valarith.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-03  |  18.1 KB  |  706 lines
  1. /* Perform arithmetic and other operations on values, for GDB.
  2.    Copyright 1986, 1989, 1991, 1992 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "defs.h"
  21. #include "value.h"
  22. #include "symtab.h"
  23. #include "gdbtypes.h"
  24. #include "expression.h"
  25. #include "target.h"
  26. #include <string.h>
  27.  
  28. static value
  29. value_subscripted_rvalue PARAMS ((value, value));
  30.  
  31.  
  32. value
  33. value_add (arg1, arg2)
  34.     value arg1, arg2;
  35. {
  36.   register value valint, valptr;
  37.   register int len;
  38.  
  39.   COERCE_ARRAY (arg1);
  40.   COERCE_ARRAY (arg2);
  41.  
  42.   if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
  43.        || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR)
  44.       &&
  45.       (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT
  46.        || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT))
  47.     /* Exactly one argument is a pointer, and one is an integer.  */
  48.     {
  49.       if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
  50.     {
  51.       valptr = arg1;
  52.       valint = arg2;
  53.     }
  54.       else
  55.     {
  56.       valptr = arg2;
  57.       valint = arg1;
  58.     }
  59.       len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
  60.       if (len == 0) len = 1;    /* For (void *) */
  61.       return value_from_longest (VALUE_TYPE (valptr),
  62.                   value_as_long (valptr)
  63.                   + (len * value_as_long (valint)));
  64.     }
  65.  
  66.   return value_binop (arg1, arg2, BINOP_ADD);
  67. }
  68.  
  69. value
  70. value_sub (arg1, arg2)
  71.     value arg1, arg2;
  72. {
  73.  
  74.   COERCE_ARRAY (arg1);
  75.   COERCE_ARRAY (arg2);
  76.  
  77.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
  78.     {
  79.       if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
  80.     {
  81.       /* pointer - integer.  */
  82.       return value_from_longest
  83.         (VALUE_TYPE (arg1),
  84.          value_as_long (arg1)
  85.          - (TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))
  86.         * value_as_long (arg2)));
  87.     }
  88.       else if (VALUE_TYPE (arg1) == VALUE_TYPE (arg2))
  89.     {
  90.       /* pointer to <type x> - pointer to <type x>.  */
  91.       return value_from_longest
  92.         (builtin_type_long,        /* FIXME -- should be ptrdiff_t */
  93.          (value_as_long (arg1) - value_as_long (arg2))
  94.          / TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))));
  95.     }
  96.       else
  97.     {
  98.       error ("\
  99. First argument of `-' is a pointer and second argument is neither\n\
  100. an integer nor a pointer of the same type.");
  101.     }
  102.     }
  103.  
  104.   return value_binop (arg1, arg2, BINOP_SUB);
  105. }
  106.  
  107. /* Return the value of ARRAY[IDX].  */
  108.  
  109. value
  110. value_subscript (array, idx)
  111.      value array, idx;
  112. {
  113.   if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_ARRAY
  114.       && VALUE_LVAL (array) != lval_memory)
  115.     return value_subscripted_rvalue (array, idx);
  116.   else
  117.     return value_ind (value_add (array, idx));
  118. }
  119.  
  120. /* Return the value of EXPR[IDX], expr an aggregate rvalue
  121.    (eg, a vector register).  This routine used to promote floats
  122.    to doubles, but no longer does.  */
  123.  
  124. static value
  125. value_subscripted_rvalue (array, idx)
  126.      value array, idx;
  127. {
  128.   struct type *elt_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
  129.   int elt_size = TYPE_LENGTH (elt_type);
  130.   int elt_offs = elt_size * longest_to_int (value_as_long (idx));
  131.   value v;
  132.  
  133.   if (elt_offs >= TYPE_LENGTH (VALUE_TYPE (array)))
  134.     error ("no such vector element");
  135.  
  136.   v = allocate_value (elt_type);
  137.   bcopy (VALUE_CONTENTS (array) + elt_offs, VALUE_CONTENTS (v), elt_size);
  138.  
  139.   if (VALUE_LVAL (array) == lval_internalvar)
  140.     VALUE_LVAL (v) = lval_internalvar_component;
  141.   else
  142.     VALUE_LVAL (v) = not_lval;
  143.   VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
  144.   VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
  145.   VALUE_BITSIZE (v) = elt_size * 8;
  146.   return v;
  147. }
  148.  
  149. /* Check to see if either argument is a structure.  This is called so
  150.    we know whether to go ahead with the normal binop or look for a 
  151.    user defined function instead.
  152.  
  153.    For now, we do not overload the `=' operator.  */
  154.  
  155. int
  156. binop_user_defined_p (op, arg1, arg2)
  157.      enum exp_opcode op;
  158.      value arg1, arg2;
  159. {
  160.   if (op == BINOP_ASSIGN)
  161.     return 0;
  162.   return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
  163.       || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_STRUCT
  164.       || (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
  165.           && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT)
  166.       || (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_REF
  167.           && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_STRUCT));
  168. }
  169.  
  170. /* Check to see if argument is a structure.  This is called so
  171.    we know whether to go ahead with the normal unop or look for a 
  172.    user defined function instead.
  173.  
  174.    For now, we do not overload the `&' operator.  */
  175.  
  176. int unop_user_defined_p (op, arg1)
  177.      enum exp_opcode op;
  178.      value arg1;
  179. {
  180.   if (op == UNOP_ADDR)
  181.     return 0;
  182.   return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
  183.       || (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
  184.           && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT));
  185. }
  186.  
  187. /* We know either arg1 or arg2 is a structure, so try to find the right
  188.    user defined function.  Create an argument vector that calls 
  189.    arg1.operator @ (arg1,arg2) and return that value (where '@' is any
  190.    binary operator which is legal for GNU C++).
  191.  
  192.    OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
  193.    is the opcode saying how to modify it.  Otherwise, OTHEROP is
  194.    unused.  */
  195.  
  196. value
  197. value_x_binop (arg1, arg2, op, otherop)
  198.      value arg1, arg2;
  199.      enum exp_opcode op, otherop;
  200. {
  201.   value * argvec;
  202.   char *ptr;
  203.   char tstr[13];
  204.   int static_memfuncp;
  205.  
  206.   COERCE_REF (arg1);
  207.   COERCE_REF (arg2);
  208.   COERCE_ENUM (arg1);
  209.   COERCE_ENUM (arg2);
  210.  
  211.   /* now we know that what we have to do is construct our
  212.      arg vector and find the right function to call it with.  */
  213.  
  214.   if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
  215.     error ("Can't do that binary op on that type");  /* FIXME be explicit */
  216.  
  217.   argvec = (value *) alloca (sizeof (value) * 4);
  218.   argvec[1] = value_addr (arg1);
  219.   argvec[2] = arg2;
  220.   argvec[3] = 0;
  221.  
  222.   /* make the right function name up */  
  223.   strcpy(tstr, "operator__");
  224.   ptr = tstr+8;
  225.   switch (op)
  226.     {
  227.     case BINOP_ADD:    strcpy(ptr,"+"); break;
  228.     case BINOP_SUB:    strcpy(ptr,"-"); break;
  229.     case BINOP_MUL:    strcpy(ptr,"*"); break;
  230.     case BINOP_DIV:    strcpy(ptr,"/"); break;
  231.     case BINOP_REM:    strcpy(ptr,"%"); break;
  232.     case BINOP_LSH:    strcpy(ptr,"<<"); break;
  233.     case BINOP_RSH:    strcpy(ptr,">>"); break;
  234.     case BINOP_LOGAND:    strcpy(ptr,"&"); break;
  235.     case BINOP_LOGIOR:    strcpy(ptr,"|"); break;
  236.     case BINOP_LOGXOR:    strcpy(ptr,"^"); break;
  237.     case BINOP_AND:    strcpy(ptr,"&&"); break;
  238.     case BINOP_OR:    strcpy(ptr,"||"); break;
  239.     case BINOP_MIN:    strcpy(ptr,"<?"); break;
  240.     case BINOP_MAX:    strcpy(ptr,">?"); break;
  241.     case BINOP_ASSIGN:    strcpy(ptr,"="); break;
  242.     case BINOP_ASSIGN_MODIFY:    
  243.       switch (otherop)
  244.     {
  245.     case BINOP_ADD:      strcpy(ptr,"+="); break;
  246.     case BINOP_SUB:      strcpy(ptr,"-="); break;
  247.     case BINOP_MUL:      strcpy(ptr,"*="); break;
  248.     case BINOP_DIV:      strcpy(ptr,"/="); break;
  249.     case BINOP_REM:      strcpy(ptr,"%="); break;
  250.     case BINOP_LOGAND:   strcpy(ptr,"&="); break;
  251.     case BINOP_LOGIOR:   strcpy(ptr,"|="); break;
  252.     case BINOP_LOGXOR:   strcpy(ptr,"^="); break;
  253.     default:
  254.       error ("Invalid binary operation specified.");
  255.     }
  256.       break;
  257.     case BINOP_SUBSCRIPT: strcpy(ptr,"[]"); break;
  258.     case BINOP_EQUAL:      strcpy(ptr,"=="); break;
  259.     case BINOP_NOTEQUAL:  strcpy(ptr,"!="); break;
  260.     case BINOP_LESS:      strcpy(ptr,"<"); break;
  261.     case BINOP_GTR:       strcpy(ptr,">"); break;
  262.     case BINOP_GEQ:       strcpy(ptr,">="); break;
  263.     case BINOP_LEQ:       strcpy(ptr,"<="); break;
  264.     default:
  265.       error ("Invalid binary operation specified.");
  266.     }
  267.   argvec[0] = value_struct_elt (&arg1, argvec+1, tstr, &static_memfuncp, "structure");
  268.   if (argvec[0])
  269.     {
  270.       if (static_memfuncp)
  271.     {
  272.       argvec[1] = argvec[0];
  273.       argvec++;
  274.     }
  275.       return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
  276.     }
  277.   error ("member function %s not found", tstr);
  278. #ifdef lint
  279.   return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
  280. #endif
  281. }
  282.  
  283. /* We know that arg1 is a structure, so try to find a unary user
  284.    defined operator that matches the operator in question.  
  285.    Create an argument vector that calls arg1.operator @ (arg1)
  286.    and return that value (where '@' is (almost) any unary operator which
  287.    is legal for GNU C++).  */
  288.  
  289. value
  290. value_x_unop (arg1, op)
  291.      value arg1;
  292.      enum exp_opcode op;
  293. {
  294.   value * argvec;
  295.   char *ptr;
  296.   char tstr[13];
  297.   int static_memfuncp;
  298.  
  299.   COERCE_ENUM (arg1);
  300.  
  301.   /* now we know that what we have to do is construct our
  302.      arg vector and find the right function to call it with.  */
  303.  
  304.   if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
  305.     error ("Can't do that unary op on that type");  /* FIXME be explicit */
  306.  
  307.   argvec = (value *) alloca (sizeof (value) * 3);
  308.   argvec[1] = value_addr (arg1);
  309.   argvec[2] = 0;
  310.  
  311.   /* make the right function name up */  
  312.   strcpy(tstr,"operator__");
  313.   ptr = tstr+8;
  314.   switch (op)
  315.     {
  316.     case UNOP_PREINCREMENT:    strcpy(ptr,"++"); break;
  317.     case UNOP_PREDECREMENT:    strcpy(ptr,"++"); break;
  318.     case UNOP_POSTINCREMENT:    strcpy(ptr,"++"); break;
  319.     case UNOP_POSTDECREMENT:    strcpy(ptr,"++"); break;
  320.     case UNOP_ZEROP:    strcpy(ptr,"!"); break;
  321.     case UNOP_LOGNOT:    strcpy(ptr,"~"); break;
  322.     case UNOP_NEG:    strcpy(ptr,"-"); break;
  323.     default:
  324.       error ("Invalid binary operation specified.");
  325.     }
  326.   argvec[0] = value_struct_elt (&arg1, argvec+1, tstr, &static_memfuncp, "structure");
  327.   if (argvec[0])
  328.     {
  329.       if (static_memfuncp)
  330.     {
  331.       argvec[1] = argvec[0];
  332.       argvec++;
  333.     }
  334.       return call_function_by_hand (argvec[0], 1 - static_memfuncp, argvec + 1);
  335.     }
  336.   error ("member function %s not found", tstr);
  337.   return 0;  /* For lint -- never reached */
  338. }
  339.  
  340. /* Perform a binary operation on two integers or two floats.
  341.    Does not support addition and subtraction on pointers;
  342.    use value_add or value_sub if you want to handle those possibilities.  */
  343.  
  344. value
  345. value_binop (arg1, arg2, op)
  346.      value arg1, arg2;
  347.      enum exp_opcode op;
  348. {
  349.   register value val;
  350.  
  351.   COERCE_ENUM (arg1);
  352.   COERCE_ENUM (arg2);
  353.  
  354.   if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
  355.        &&
  356.        TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
  357.       ||
  358.       (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
  359.        &&
  360.        TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT))
  361.     error ("Argument to arithmetic operation not a number.");
  362.  
  363.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
  364.       ||
  365.       TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
  366.     {
  367.       double v1, v2, v;
  368.       v1 = value_as_double (arg1);
  369.       v2 = value_as_double (arg2);
  370.       switch (op)
  371.     {
  372.     case BINOP_ADD:
  373.       v = v1 + v2;
  374.       break;
  375.  
  376.     case BINOP_SUB:
  377.       v = v1 - v2;
  378.       break;
  379.  
  380.     case BINOP_MUL:
  381.       v = v1 * v2;
  382.       break;
  383.  
  384.     case BINOP_DIV:
  385.       v = v1 / v2;
  386.       break;
  387.  
  388.     default:
  389.       error ("Integer-only operation on floating point number.");
  390.     }
  391.  
  392.       val = allocate_value (builtin_type_double);
  393.       SWAP_TARGET_AND_HOST (&v, sizeof (v));
  394.       *(double *) VALUE_CONTENTS_RAW (val) = v;
  395.     }
  396.   else
  397.     /* Integral operations here.  */
  398.     {
  399.       /* Should we promote to unsigned longest?  */
  400.       if ((TYPE_UNSIGNED (VALUE_TYPE (arg1))
  401.        || TYPE_UNSIGNED (VALUE_TYPE (arg2)))
  402.       && (TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)
  403.           || TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)))
  404.     {
  405.       unsigned LONGEST v1, v2, v;
  406.       v1 = (unsigned LONGEST) value_as_long (arg1);
  407.       v2 = (unsigned LONGEST) value_as_long (arg2);
  408.       
  409.       switch (op)
  410.         {
  411.         case BINOP_ADD:
  412.           v = v1 + v2;
  413.           break;
  414.           
  415.         case BINOP_SUB:
  416.           v = v1 - v2;
  417.           break;
  418.           
  419.         case BINOP_MUL:
  420.           v = v1 * v2;
  421.           break;
  422.           
  423.         case BINOP_DIV:
  424.           v = v1 / v2;
  425.           break;
  426.           
  427.         case BINOP_REM:
  428.           v = v1 % v2;
  429.           break;
  430.           
  431.         case BINOP_LSH:
  432.           v = v1 << v2;
  433.           break;
  434.           
  435.         case BINOP_RSH:
  436.           v = v1 >> v2;
  437.           break;
  438.           
  439.         case BINOP_LOGAND:
  440.           v = v1 & v2;
  441.           break;
  442.           
  443.         case BINOP_LOGIOR:
  444.           v = v1 | v2;
  445.           break;
  446.           
  447.         case BINOP_LOGXOR:
  448.           v = v1 ^ v2;
  449.           break;
  450.           
  451.         case BINOP_AND:
  452.           v = v1 && v2;
  453.           break;
  454.           
  455.         case BINOP_OR:
  456.           v = v1 || v2;
  457.           break;
  458.           
  459.         case BINOP_MIN:
  460.           v = v1 < v2 ? v1 : v2;
  461.           break;
  462.           
  463.         case BINOP_MAX:
  464.           v = v1 > v2 ? v1 : v2;
  465.           break;
  466.           
  467.         default:
  468.           error ("Invalid binary operation on numbers.");
  469.         }
  470.  
  471.       val = allocate_value (BUILTIN_TYPE_UNSIGNED_LONGEST);
  472.       SWAP_TARGET_AND_HOST (&v, sizeof (v));
  473.       *(unsigned LONGEST *) VALUE_CONTENTS_RAW (val) = v;
  474.     }
  475.       else
  476.     {
  477.       LONGEST v1, v2, v;
  478.       v1 = value_as_long (arg1);
  479.       v2 = value_as_long (arg2);
  480.       
  481.       switch (op)
  482.         {
  483.         case BINOP_ADD:
  484.           v = v1 + v2;
  485.           break;
  486.           
  487.         case BINOP_SUB:
  488.           v = v1 - v2;
  489.           break;
  490.           
  491.         case BINOP_MUL:
  492.           v = v1 * v2;
  493.           break;
  494.           
  495.         case BINOP_DIV:
  496.           v = v1 / v2;
  497.           break;
  498.           
  499.         case BINOP_REM:
  500.           v = v1 % v2;
  501.           break;
  502.           
  503.         case BINOP_LSH:
  504.           v = v1 << v2;
  505.           break;
  506.           
  507.         case BINOP_RSH:
  508.           v = v1 >> v2;
  509.           break;
  510.           
  511.         case BINOP_LOGAND:
  512.           v = v1 & v2;
  513.           break;
  514.           
  515.         case BINOP_LOGIOR:
  516.           v = v1 | v2;
  517.           break;
  518.           
  519.         case BINOP_LOGXOR:
  520.           v = v1 ^ v2;
  521.           break;
  522.           
  523.         case BINOP_AND:
  524.           v = v1 && v2;
  525.           break;
  526.           
  527.         case BINOP_OR:
  528.           v = v1 || v2;
  529.           break;
  530.           
  531.         case BINOP_MIN:
  532.           v = v1 < v2 ? v1 : v2;
  533.           break;
  534.           
  535.         case BINOP_MAX:
  536.           v = v1 > v2 ? v1 : v2;
  537.           break;
  538.           
  539.         default:
  540.           error ("Invalid binary operation on numbers.");
  541.         }
  542.       
  543.       val = allocate_value (BUILTIN_TYPE_LONGEST);
  544.       SWAP_TARGET_AND_HOST (&v, sizeof (v));
  545.       *(LONGEST *) VALUE_CONTENTS_RAW (val) = v;
  546.     }
  547.     }
  548.  
  549.   return val;
  550. }
  551.  
  552. /* Simulate the C operator ! -- return 1 if ARG1 contains zeros.  */
  553.  
  554. int
  555. value_zerop (arg1)
  556.      value arg1;
  557. {
  558.   register int len;
  559.   register char *p;
  560.  
  561.   COERCE_ARRAY (arg1);
  562.  
  563.   len = TYPE_LENGTH (VALUE_TYPE (arg1));
  564.   p = VALUE_CONTENTS (arg1);
  565.  
  566.   while (--len >= 0)
  567.     {
  568.       if (*p++)
  569.     break;
  570.     }
  571.  
  572.   return len < 0;
  573. }
  574.  
  575. /* Simulate the C operator == by returning a 1
  576.    iff ARG1 and ARG2 have equal contents.  */
  577.  
  578. int
  579. value_equal (arg1, arg2)
  580.      register value arg1, arg2;
  581.  
  582. {
  583.   register int len;
  584.   register char *p1, *p2;
  585.   enum type_code code1;
  586.   enum type_code code2;
  587.  
  588.   COERCE_ARRAY (arg1);
  589.   COERCE_ARRAY (arg2);
  590.  
  591.   code1 = TYPE_CODE (VALUE_TYPE (arg1));
  592.   code2 = TYPE_CODE (VALUE_TYPE (arg2));
  593.  
  594.   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
  595.     return value_as_long (arg1) == value_as_long (arg2);
  596.   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
  597.        && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
  598.     return value_as_double (arg1) == value_as_double (arg2);
  599.  
  600.   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
  601.      is bigger.  */
  602.   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
  603.     return value_as_pointer (arg1) == (CORE_ADDR) value_as_long (arg2);
  604.   else if (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT)
  605.     return (CORE_ADDR) value_as_long (arg1) == value_as_pointer (arg2);
  606.  
  607.   else if (code1 == code2
  608.        && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
  609.            == TYPE_LENGTH (VALUE_TYPE (arg2))))
  610.     {
  611.       p1 = VALUE_CONTENTS (arg1);
  612.       p2 = VALUE_CONTENTS (arg2);
  613.       while (--len >= 0)
  614.     {
  615.       if (*p1++ != *p2++)
  616.         break;
  617.     }
  618.       return len < 0;
  619.     }
  620.   else
  621.     {
  622.       error ("Invalid type combination in equality test.");
  623.       return 0;  /* For lint -- never reached */
  624.     }
  625. }
  626.  
  627. /* Simulate the C operator < by returning 1
  628.    iff ARG1's contents are less than ARG2's.  */
  629.  
  630. int
  631. value_less (arg1, arg2)
  632.      register value arg1, arg2;
  633. {
  634.   register enum type_code code1;
  635.   register enum type_code code2;
  636.  
  637.   COERCE_ARRAY (arg1);
  638.   COERCE_ARRAY (arg2);
  639.  
  640.   code1 = TYPE_CODE (VALUE_TYPE (arg1));
  641.   code2 = TYPE_CODE (VALUE_TYPE (arg2));
  642.  
  643.   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
  644.     {
  645.       if (TYPE_UNSIGNED (VALUE_TYPE (arg1))
  646.        || TYPE_UNSIGNED (VALUE_TYPE (arg2)))
  647.     return ((unsigned LONGEST) value_as_long (arg1)
  648.         < (unsigned LONGEST) value_as_long (arg2));
  649.       else
  650.     return value_as_long (arg1) < value_as_long (arg2);
  651.     }
  652.   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
  653.        && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
  654.     return value_as_double (arg1) < value_as_double (arg2);
  655.   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
  656.     return value_as_pointer (arg1) < value_as_pointer (arg2);
  657.  
  658.   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
  659.      is bigger.  */
  660.   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
  661.     return value_as_pointer (arg1) < (CORE_ADDR) value_as_long (arg2);
  662.   else if (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT)
  663.     return (CORE_ADDR) value_as_long (arg1) < value_as_pointer (arg2);
  664.  
  665.   else
  666.     {
  667.       error ("Invalid type combination in ordering comparison.");
  668.       return 0;
  669.     }
  670. }
  671.  
  672. /* The unary operators - and ~.  Both free the argument ARG1.  */
  673.  
  674. value
  675. value_neg (arg1)
  676.      register value arg1;
  677. {
  678.   register struct type *type;
  679.  
  680.   COERCE_ENUM (arg1);
  681.  
  682.   type = VALUE_TYPE (arg1);
  683.  
  684.   if (TYPE_CODE (type) == TYPE_CODE_FLT)
  685.     return value_from_double (type, - value_as_double (arg1));
  686.   else if (TYPE_CODE (type) == TYPE_CODE_INT)
  687.     return value_from_longest (type, - value_as_long (arg1));
  688.   else {
  689.     error ("Argument to negate operation not a number.");
  690.     return 0;  /* For lint -- never reached */
  691.   }
  692. }
  693.  
  694. value
  695. value_lognot (arg1)
  696.      register value arg1;
  697. {
  698.   COERCE_ENUM (arg1);
  699.  
  700.   if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
  701.     error ("Argument to complement operation not an integer.");
  702.  
  703.   return value_from_longest (VALUE_TYPE (arg1), ~ value_as_long (arg1));
  704. }
  705.  
  706.